function getFirstWorld(msg: string) {
    console.log(msg.split(' ')[0])
}

// TypeSctipt中的类型
const str: String = 'Hello, TypeScript!'
const num: Number = 123
const bool: Boolean = true
const str1 = "Hello, TypeScript!"
const num1 = 123
const bool1 = true

const strs: string[] = ['Hello', 'TypeScript', '!']
const nums: number[] = [1, 2, 3]
const strs1 = ['Hello', 'TypeScript', '!']// 类型推断

const array =[] // 无法进行类型推断, 类型为any


getFirstWorld('Hello, TypeScript!')
getFirstWorld("123")

// 定义对象类型
interface User{
    name: string // 必选
    age: number // 必选
    gender?: string // 可选
}
// 在声明变量的时候将其关联到类型上
const user: User = {
    name: 'John',
    age: 20
}
const user2: User = {
    name: 'John',
    age: 20,
    gender: 'Male'
}
console.log(user, user2)

// 继承
interface Admin extends User {
    permissionLevel: number
}
const admin: Admin = {
    name: '罗如烈',
    age: 20,
    permissionLevel: 10
}
console.log(admin)


// 定义类
class Animal {
    name: string
    constructor(name: string) {
        this.name = name
    }
    sayHello(): void {
        console.log(`${this.name} says hello!`)
    }
}

const dog = new Animal('Dog')
dog.sayHello()

// 联合类型
function counter(count: number | string) {
    console.log(`The current count is ${count}`)
}
counter(99)
counter('99')
// 函数
// 写法1: 函数声明
function sum1(a: number, b: number): number {
    return a + b
}
// 写法2: 函数表达式
const sum2 = function(a: number, b: number): number {
    return a + b
}
// 写法3: 箭头函数
const sum3 = (a: number, b: number) => a + b

// 写法4： 对象上的方法
const obj = {
    sum4(a: number, b: number): number {
        return a + b
    }
}
// 更多写法...
// 函数的可选参数, 可选参数必须排在必选参数的后面
function sum(a: number, b: number, c?:boolean) : number {
    return a + b + (c? 100 : 0)
}

// 异步函数
function queryData(): Promise<string> {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('Data fetched')
        }, 1000)
    })
}
queryData().then(data => console.log(data))
// 函数重载
function add(a: number, b: number): number
function add(a: string, b: string): string
function add(a: any, b: any): number | string {
    if (typeof a === 'number' && typeof b === 'number') {
        return a + b
    } else if (typeof a === 'string' && typeof b === 'string') {
        return a + b
    } else {
        throw new Error('Both inputs must be numbers or strings')
    }
}
console.log(add(1, 2))
console.log(add('Hello', ' TypeScript!'))
//console.log(add(1, ' TypeScript!')) // bao错

// 类型断言
const strResult = add('Hello', ' TypeScript!') as string // 断定返回值是string类型
console.log(strResult.split(' ')) // 正常使用

const result = add(1, 2)
//console.log(result.split(' ')) // 编译时会报错, 因为不确定返回值是number还是string
